import {createRouter, createWebHashHistory, createWebHistory} from 'vue-router'
import s94Mjs from "s94-js";
import {_href, _get as s94_get, get_os, s94_event} from "@/js/s94_tool.js";
import {ajax, wechat_share} from "@/js/api_tool.js";
import {use_this_user} from "@/store/this_user.js";

export {view_component, _get, _base, has_path, href_path, href_handle}

// 页面不存在的视图
/**试图组件MAP，键值为view页面地址，例如：order/index
 * @type {{"view路径": Promise<{readonly default?: Router}>}}
 */
const VIEW_COMPONENT_MAP = {}

// 获取所有页面组件的导入方法
let import_view_function_map = import.meta.glob('@/views/**/*.vue');

let routes_list = [];
Object.keys(import_view_function_map).forEach(path=>{
    let view_key = path.replace(/^.*?\/views\/(.+)\.vue$/,'$1')
    VIEW_COMPONENT_MAP[view_key] = import_view_function_map[path]();

    let router_row = {
        path:'/' + view_key,
        component(){ return VIEW_COMPONENT_MAP[view_key]; }
    }
    routes_list.push(router_row);
})

//自定义部分路由
routes_list.push({
    path:'/',
    component(){ return VIEW_COMPONENT_MAP['index']; }
});
routes_list.push({
    path:'/:path*',
    component(){ return VIEW_COMPONENT_MAP['404']; }
});
const router = createRouter({
    history: createWebHashHistory(),
    routes: routes_list,
});
// -----------------------------------------------路由相关的方法-------------------------------------
/**返回指定的视图组件
 * @param {string} path
 * @returns {Promise<{readonly default?: Router}>|void}
 */
function view_component(path){
    return VIEW_COMPONENT_MAP[path];
}

/**获取路由查询参数
 * @param {string} [key] 参数名，可以为空，为空表示获取所有，会返回对象
 * @param {string} [def] 默认值，参数不存在时返回的值
 * @returns {string|Object}
 */
function _get(key, def){
    return s94_get(key, def);
    let query = router.currentRoute.value.query || {};
    try {
        // 尝试获取url的 search 部分
        let search = window.location.search ? window.location.search.substring(1) : '';
        if (search) {
            search.split('&').forEach(row => {
                if (!row) return;
                let kv = row.split('=');
                query[kv[0]] = kv[1] || '';
            })
        }
    } catch (e) {}
    if (!key) return query;
    return key in query ? query[key] : def;
}
/**返回路由的基础部分，也就是url访问的路径
 * @returns {string}
 * @private
 */
function _base(){
    try {
        return window.location.origin+window.location.pathname;
    } catch (e) {
        return '';
    }
}
/**判断是否存在指定路径的路由
 * @param path
 * @returns {boolean}
 */
function has_path(path){
    const routes = router.getRoutes();
    return routes.some(route => route.path === path);
}
/**href转路由path，不属于路由则返回null
 * @param href
 * @returns {string|null}
 */
function href_path(href){
    if (!href) return null;
    // 判断 href 是否和当前路由同源，如果同源，就可以初步判断可能为路由地址
    if (/^([a-z:]+)?\/\//.test(href)){
        let base = _base();
        if (href.indexOf('//')===0) base = base.replace(/^[^\/]*/,'');
        //这里兼容 / 和 /index.html 属于同源
        base = base.replace(/index\.html$/, '');
        if (href.indexOf(base)!==0) return null;
        let search = '';
        href = href.substring(base.length).replace(/^(index\.html)?(\?[^#]*)?#/, (m0,m1,m2)=>{
            if (m2) search = m2.substring(1);
            return '';
        });
        if (search) {
            href += (~href.indexOf('?')?'&':'?') + search;
        }
    }
    let path = href.split('?').shift();
    // 判断路径是否属于路由，不属于返回null
    return router.has_path(path) ? href : null;
}

/**URL（非路由路径）的push操作，可以通过重构来自定义
 * @param url
 */
router.push_url = function (url){
    if (typeof window === 'object') window.location.href = url;
}
/**URL（非路由路径）的replace操作，可以通过重构来自定义
 * @param url
 */
router.replace_url = function (url){
    if (typeof window === 'object') window.location.replace(url);
}
/**统一的链接处理函数，可以设定倒计时，倒计时之前再次调用无效
 * @param {String|Number} href 链接地址，可以用特殊数值表示特殊地址，例如：上一页(-1)
 * @param {Number} [timeout] 倒计时，毫秒
 * @param {*} [is_replace] 是否为replace处理，replace处理不会添加堆栈，影响回退执行效果
 */
function href_handle(href, timeout, is_replace){
    if (!href || href_handle.runing) return;
    function run(){
        router.isReady().then(()=>{
            href_handle.runing = false;
            // 数字类型的 href 处理
            if (typeof href === 'number'){
                return router.go(href);
            }
            // 判断是否属于路由路径，如果不属于，使用url相关方法
            let route_path = href_path(href);
            if (route_path){
                is_replace ? router.replace(route_path) : router.push(route_path);
            }else{
                is_replace ? router.replace_url(href) : router.push_url(href);
            }
        })
    }
    if (timeout>0){
        href_handle.runing = true;
        setTimeout(run, timeout);
    }else {
        run();
    }
    return true;
}

router._get = _get;
router._base = _base;
router.has_path = has_path;
router.href_path = href_path;
router.href_handle = href_handle;

// ------------------------------------- 以下为项目路由相关  -------------------------------------------

/**访问记录
 * @param {String} share_phone 分享者电话
 * @returns {*}
 */
function visits_log(share_phone){
    let user = use_this_user();
    if (user.id && get_os() & s94Mjs.OS_H5_WECHAT){
        let wechat_user = s94Mjs.cache("_wechat_user_");
        if (!wechat_user) return ( window.location.href = _href("/home/api/wechat_info") );
        user = {
            nickname: wechat_user.nickname,
            head_img: wechat_user.headimgurl,
            openid: `{"${wechat_user.appid}":"${wechat_user.openid}"}`
        }
    }
    function loop(){
        if (!visits_log.status) return; // 链接跳转后，终止继续记录
        ajax({
            url: "/home/visits_log/log",
            data: {
                share_phone: share_phone,
                nickname: user.nickname || '',
                head_img: user.head_img || '',
                title: document.title,
                share_id: _get("share_id", 0)
            }
        }, function (res){ setTimeout(loop, 5000) })
    }
    loop();
}
router.beforeEach((to, from, next)=>{
    // 在用户登录页，前往非首页，并且用户未登录的情况下，就跳转到首页(解决用户登录页回退一直提示未登录的问题)
    if (from.path === '/user/login' && !~['/','/index'].indexOf(to.path) && !use_this_user().id){
        next('/index')
    }else {
        next();
    }
})
//
router.afterEach((to, from) => {
    console.log('router.afterEach', to.fullPath);
    s94_event('router.after', {to, from})
    // 标题
    let title = _get("_title_");
    if(title) document.title = title;
    // 微信用户授权信息
    let param = _get("", {});
    if (param["appid"] && param["openid"]){
        s94Mjs.cache({_wechat_user_: param})
    }
    // 分享来的链接
    let share_phone = _get("_share_phone_");
    if (share_phone && /^1\d{10}$/.test(share_phone)) {
        s94Mjs.cache({_share_phone_: share_phone});
        // 请求访问记录
        visits_log.status = true;
        visits_log(share_phone);
    }else {
        visits_log.status = false;
    }

    //设置分享数据
    setTimeout(wechat_share, 50)

})

export default router;


